%%capture
!pip install datasets

# Dataset
from datasets import load_dataset
# pandas
import pandas as pd
# numpy
import numpy as np
# graficos
import matplotlib.pyplot as plt
from matplotlib import ticker
from matplotlib.ticker import FuncFormatter
import seaborn as sns
import plotly.express as px

# load dataset from url
%%capture
dataset = load_dataset("maharshipandya/spotify-tracks-dataset")
df = pd.DataFrame(dataset['train'])

df

# cantidad de géneros del dataset
genre_most_repeat = df['track_genre'].value_counts(dropna=False).reset_index()
genre_most_repeat.columns = ['genre', 'count']
genre_most_repeat

# Crear un gráfico de barras
plt.figure(figsize=(15,6))
plt.bar(genre_most_repeat['genre'], genre_most_repeat['count'])

# Establecer etiquetas de los ejes
plt.xlabel('Género musical')
plt.ylabel('Cantidad de apariciones en el dataset')

# Establecer título
plt.title('Cantidad de géneros en el dataset')

# Rotar etiquetas del eje x para mejor visualización
plt.xticks(rotation=90, ha='right')

# Mostrar el gráfico
plt.show()

#tomar los 300 mas populares
top_100 = df.nlargest(300, 'popularity')
#grafico de los generos de los 300 mas populares
genre_counts = top_100['track_genre'].value_counts()
plt.figure(figsize=(10, 6))
genre_counts.plot(kind='bar', color= 'pink')
plt.xlabel('tipo de genero')
plt.ylabel('Cantidad')
plt.title('Género de las 300 canciones más populares')
plt.xticks(rotation=45, ha='right')
plt.tight_layout()
plt.show()

# Promedio de la popularidad por género musical
popularity_genre = df.groupby('track_genre')['popularity'].mean().reset_index()
popularity_genre = popularity_genre.sort_values(by='popularity')

# Crear un gráfico de barras
plt.figure(figsize=(15,6))
plt.bar(popularity_genre['track_genre'], popularity_genre['popularity'])

# Establecer etiquetas de los ejes
plt.xlabel('Género musical')
plt.ylabel('Popularidad promedio')

# Establecer título
plt.title('Popularidad promedio de los géneros musicales')

# Rotar etiquetas del eje x para mejor visualización
plt.xticks(rotation=90, ha='right')

# Mostrar el gráfico
plt.show()

# Filtrar el DataFrame por género (por ejemplo, pop)
pop_df = df[df['track_genre'] == 'pop']

# Calcular la matriz de correlación para el género "pop"
correlation_matrix = pop_df[['danceability', 'energy', 'speechiness', 'acousticness', 'instrumentalness', 'liveness', 'valence', 'tempo']].corr()
# Crear un mapa de calor para visualizar la matriz de correlación
plt.figure(figsize=(10, 8))
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', fmt=".2f")
plt.title('Matriz de Correlación entre Características genero pop')
plt.show()

# Filtrar el DataFrame por género (por ejemplo, dance)
dance_df = df[df['track_genre'] == 'dance']

# Calcular la matriz de correlación para el género "dance"
correlation_matrix = dance_df[['danceability', 'energy', 'speechiness', 'acousticness', 'instrumentalness', 'liveness', 'valence', 'tempo']].corr()
# Crear un mapa de calor para visualizar la matriz de correlación
plt.figure(figsize=(10, 8))
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', fmt=".2f")
plt.title('Matriz de Correlación entre Características genero dance')
plt.show()

# Filtrar el DataFrame por género (por ejemplo, latino)
latino_df = df[df['track_genre'] == 'latino']

# Calcular la matriz de correlación para el género "latino"
correlation_matrix = latino_df[['danceability', 'energy', 'speechiness', 'acousticness', 'instrumentalness', 'liveness', 'valence', 'tempo']].corr()
# Crear un mapa de calor para visualizar la matriz de correlación
plt.figure(figsize=(10, 8))
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', fmt=".2f")
plt.title('Matriz de Correlación entre Características genero latino')
plt.show()

# Filtrar el DataFrame por género (por ejemplo, reggaeton)
reggaeton_df = df[df['track_genre'] == 'reggaeton']

# Calcular la matriz de correlación para el género "reggaeton"
correlation_matrix = reggaeton_df[['danceability', 'energy', 'speechiness', 'acousticness', 'instrumentalness', 'liveness', 'valence', 'tempo']].corr()
# Crear un mapa de calor para visualizar la matriz de correlación
plt.figure(figsize=(10, 8))
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', fmt=".2f")
plt.title('Matriz de Correlación entre Características genero reggaeton')
plt.show()

# Filtrar el DataFrame por género (por ejemplo, hip-hop)
hip_hop_df = df[df['track_genre'] == 'hip-hop']

# Calcular la matriz de correlación para el género "hip-hop"
correlation_matrix = hip_hop_df[['danceability', 'energy', 'speechiness', 'acousticness', 'instrumentalness', 'liveness', 'valence', 'tempo']].corr()
# Crear un mapa de calor para visualizar la matriz de correlación
plt.figure(figsize=(10, 8))
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', fmt=".2f")
plt.title('Matriz de Correlación entre Características genero hip_hop')
plt.show()

# Filtrar el DataFrame por género (por ejemplo, reggae)
reggae_df = df[df['track_genre'] == 'reggae']

# Calcular la matriz de correlación para el género "reggae"
correlation_matrix = reggae_df[['danceability', 'energy', 'speechiness', 'acousticness', 'instrumentalness', 'liveness', 'valence', 'tempo']].corr()
# Crear un mapa de calor para visualizar la matriz de correlación
plt.figure(figsize=(10, 8))
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', fmt=".2f")
plt.title('Matriz de Correlación entre Características genero reggae')
plt.show()

# Filtrar el DataFrame por género (por ejemplo, rock)
rock_df = df[df['track_genre'] == 'rock']

# Calcular la matriz de correlación para el género "rock"
correlation_matrix = rock_df[['danceability', 'energy', 'speechiness', 'acousticness', 'instrumentalness', 'liveness', 'valence', 'tempo']].corr()
# Crear un mapa de calor para visualizar la matriz de correlación
plt.figure(figsize=(10, 8))
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', fmt=".2f")
plt.title('Matriz de Correlación entre Características genero rock')
plt.show()

# Filtrar el DataFrame por género (por ejemplo, edm)
edm_df = df[df['track_genre'] == 'edm']

# Calcular la matriz de correlación para el género "edm"
correlation_matrix = edm_df[['danceability', 'energy', 'speechiness', 'acousticness', 'instrumentalness', 'liveness', 'valence', 'tempo']].corr()
# Crear un mapa de calor para visualizar la matriz de correlación
plt.figure(figsize=(10, 8))
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', fmt=".2f")
plt.title('Matriz de Correlación entre Características genero edm')
plt.show()

# Filtrar el DataFrame por género (por ejemplo, latin)
latin_df = df[df['track_genre'] == 'latin']

# Calcular la matriz de correlación para el género "latin"
correlation_matrix = latin_df[['danceability', 'energy', 'speechiness', 'acousticness', 'instrumentalness', 'liveness', 'valence', 'tempo']].corr()
# Crear un mapa de calor para visualizar la matriz de correlación
plt.figure(figsize=(10, 8))
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', fmt=".2f")
plt.title('Matriz de Correlación entre Características genero latin')
plt.show()

# Filtrar el DataFrame por género (por ejemplo, electro)
electro_df = df[df['track_genre'] == 'electro']

# Calcular la matriz de correlación para el género "electro"
correlation_matrix = electro_df[['danceability', 'energy', 'speechiness', 'acousticness', 'instrumentalness', 'liveness', 'valence', 'tempo']].corr()
# Crear un mapa de calor para visualizar la matriz de correlación
plt.figure(figsize=(10, 8))
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', fmt=".2f")
plt.title('Matriz de Correlación entre Características genero electro')
plt.show()

# Filtrar el DataFrame por género (por ejemplo, indie)
indie_df = df[df['track_genre'] == 'indie']

# Calcular la matriz de correlación para el género "indie"
correlation_matrix = indie_df[['danceability', 'energy', 'speechiness', 'acousticness', 'instrumentalness', 'liveness', 'valence', 'tempo']].corr()
# Crear un mapa de calor para visualizar la matriz de correlación
plt.figure(figsize=(10, 8))
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', fmt=".2f")
plt.title('Matriz de Correlación entre Características genero indie')
plt.show()

# Filtrar el DataFrame por género (por ejemplo, alternative)
alternative_df = df[df['track_genre'] == 'alternative']

# Calcular la matriz de correlación para el género "alternative"
correlation_matrix = alternative_df[['danceability', 'energy', 'speechiness', 'acousticness', 'instrumentalness', 'liveness', 'valence', 'tempo']].corr()
# Crear un mapa de calor para visualizar la matriz de correlación
plt.figure(figsize=(10, 8))
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', fmt=".2f")
plt.title('Matriz de Correlación entre Características genero alternative')
plt.show()

# Filtrar el DataFrame por género (por ejemplo, house)
house_df = df[df['track_genre'] == 'house']

# Calcular la matriz de correlación para el género "house"
correlation_matrix = house_df[['danceability', 'energy', 'speechiness', 'acousticness', 'instrumentalness', 'liveness', 'valence', 'tempo']].corr()
# Crear un mapa de calor para visualizar la matriz de correlación
plt.figure(figsize=(10, 8))
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', fmt=".2f")
plt.title('Matriz de Correlación entre Características genero house')
plt.show()

# Filtrar el DataFrame por género (por ejemplo, alt-rock)
rock_df = df[df['track_genre'] == 'alt-rock']

# Calcular la matriz de correlación para el género "alt-rock"
correlation_matrix = rock_df[['danceability', 'energy', 'speechiness', 'acousticness', 'instrumentalness', 'liveness', 'valence', 'tempo']].corr()
# Crear un mapa de calor para visualizar la matriz de correlación
plt.figure(figsize=(10, 8))
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', fmt=".2f")
plt.title('Matriz de Correlación entre Características genero alt-rock')
plt.show()

# Filtrar el DataFrame por género (por ejemplo, garage)
garage_df = df[df['track_genre'] == 'garage']

# Calcular la matriz de correlación para el género "garage"
correlation_matrix = garage_df[['danceability', 'energy', 'speechiness', 'acousticness', 'instrumentalness', 'liveness', 'valence', 'tempo']].corr()
# Crear un mapa de calor para visualizar la matriz de correlación
plt.figure(figsize=(10, 8))
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', fmt=".2f")
plt.title('Matriz de Correlación entre Características genero garage')
plt.show()

# Filtrar el DataFrame por género (por ejemplo, k-pop)
garage_df = df[df['track_genre'] == 'k-pop']

# Calcular la matriz de correlación para el género "k-pop"
correlation_matrix = garage_df[['danceability', 'energy', 'speechiness', 'acousticness', 'instrumentalness', 'liveness', 'valence', 'tempo']].corr()
# Crear un mapa de calor para visualizar la matriz de correlación
plt.figure(figsize=(10, 8))
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', fmt=".2f")
plt.title('Matriz de Correlación entre Características genero k-pop')
plt.show()

# Filtrar el DataFrame por género (por ejemplo, emo)
garage_df = df[df['track_genre'] ==  'emo']

# Calcular la matriz de correlación para el género emo"
correlation_matrix = garage_df[['danceability', 'energy', 'speechiness', 'acousticness', 'instrumentalness', 'liveness', 'valence', 'tempo']].corr()
# Crear un mapa de calor para visualizar la matriz de correlación
plt.figure(figsize=(10, 8))
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', fmt=".2f")
plt.title('Matriz de Correlación entre Características genero emo')
plt.show()

# Filtrar el DataFrame por género (por ejemplo, indie-pop)
garage_df = df[df['track_genre'] == 'indie-pop']

# Calcular la matriz de correlación para el género "indie-pop"
correlation_matrix = garage_df[['danceability', 'energy', 'speechiness', 'acousticness', 'instrumentalness', 'liveness', 'valence', 'tempo']].corr()
# Crear un mapa de calor para visualizar la matriz de correlación
plt.figure(figsize=(10, 8))
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', fmt=".2f")
plt.title('Matriz de Correlación entre Características genero indie-pop')
plt.show()

# Filtrar el DataFrame por género (por ejemplo, piano)
garage_df = df[df['track_genre'] == 'piano']

# Calcular la matriz de correlación para el género "piano"
correlation_matrix = garage_df[['danceability', 'energy', 'speechiness', 'acousticness', 'instrumentalness', 'liveness', 'valence', 'tempo']].corr()
# Crear un mapa de calor para visualizar la matriz de correlación
plt.figure(figsize=(10, 8))
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', fmt=".2f")
plt.title('Matriz de Correlación entre Características genero piano')
plt.show()

# Filtrar el DataFrame por género (por ejemplo, hard-rock)
garage_df = df[df['track_genre'] == 'hard-rock']

# Calcular la matriz de correlación para el género "hard-rock"
correlation_matrix = garage_df[['danceability', 'energy', 'speechiness', 'acousticness', 'instrumentalness', 'liveness', 'valence', 'tempo']].corr()
# Crear un mapa de calor para visualizar la matriz de correlación
plt.figure(figsize=(10, 8))
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', fmt=".2f")
plt.title('Matriz de Correlación entre Características genero hard-rock')
plt.show()

# Filtrar el DataFrame por género (por ejemplo, british)
garage_df = df[df['track_genre'] == 'british']

# Calcular la matriz de correlación para el género "british"
correlation_matrix = garage_df[['danceability', 'energy', 'speechiness', 'acousticness', 'instrumentalness', 'liveness', 'valence', 'tempo']].corr()
# Crear un mapa de calor para visualizar la matriz de correlación
plt.figure(figsize=(10, 8))
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', fmt=".2f")
plt.title('Matriz de Correlación entre Características genero british')
plt.show()

# Filtrar el DataFrame por género (por ejemplo, soul)
garage_df = df[df['track_genre'] == 'soul']

# Calcular la matriz de correlación para el género "soul"
correlation_matrix = garage_df[['danceability', 'energy', 'speechiness', 'acousticness', 'instrumentalness', 'liveness', 'valence', 'tempo']].corr()
# Crear un mapa de calor para visualizar la matriz de correlación
plt.figure(figsize=(10, 8))
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', fmt=".2f")
plt.title('Matriz de Correlación entre Características genero soul')
plt.show()

# Filtrar el DataFrame por género (por ejemplo, progressive-house)
garage_df = df[df['track_genre'] == 'progressive-house']

# Calcular la matriz de correlación para el género "progressive-house"
correlation_matrix = garage_df[['danceability', 'energy', 'speechiness', 'acousticness', 'instrumentalness', 'liveness', 'valence', 'tempo']].corr()
# Crear un mapa de calor para visualizar la matriz de correlación
plt.figure(figsize=(10, 8))
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', fmt=".2f")
plt.title('Matriz de Correlación entre Características genero progressive-house')
plt.show()

# Filtrar el DataFrame por género (por ejemplo, singer-songwriter)
garage_df = df[df['track_genre'] == 'singer-songwriter']

# Calcular la matriz de correlación para el género "singer-songwriter"
correlation_matrix = garage_df[['danceability', 'energy', 'speechiness', 'acousticness', 'instrumentalness', 'liveness', 'valence', 'tempo']].corr()
# Crear un mapa de calor para visualizar la matriz de correlación
plt.figure(figsize=(10, 8))
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', fmt=".2f")
plt.title('Matriz de Correlación entre Características genero singer-songwriter')
plt.show()

# Filtrar el DataFrame por género (por ejemplo, country)
garage_df = df[df['track_genre'] == 'country']

# Calcular la matriz de correlación para el género "country"
correlation_matrix = garage_df[['danceability', 'energy', 'speechiness', 'acousticness', 'instrumentalness', 'liveness', 'valence', 'tempo']].corr()
# Crear un mapa de calor para visualizar la matriz de correlación
plt.figure(figsize=(10, 8))
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', fmt=".2f")
plt.title('Matriz de Correlación entre Características genero country')
plt.show()

# Filtrar el DataFrame por género (por ejemplo, songwriter)
garage_df = df[df['track_genre'] == 'songwriter']

# Calcular la matriz de correlación para el género "songwriter"
correlation_matrix = garage_df[['danceability', 'energy', 'speechiness', 'acousticness', 'instrumentalness', 'liveness', 'valence', 'tempo']].corr()
# Crear un mapa de calor para visualizar la matriz de correlación
plt.figure(figsize=(10, 8))
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', fmt=".2f")
plt.title('Matriz de Correlación entre Características genero songwriter')
plt.show()

# Filtrar el DataFrame por género (por ejemplo, funk)
garage_df = df[df['track_genre'] == 'funk']

# Calcular la matriz de correlación para el género "funk"
correlation_matrix = garage_df[['danceability', 'energy', 'speechiness', 'acousticness', 'instrumentalness', 'liveness', 'valence', 'tempo']].corr()
# Crear un mapa de calor para visualizar la matriz de correlación
plt.figure(figsize=(10, 8))
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', fmt=".2f")
plt.title('Matriz de Correlación entre Características genero funk')
plt.show()

# Filtrar el DataFrame por género (por ejemplo, spanish)
garage_df = df[df['track_genre'] == 'spanish']

# Calcular la matriz de correlación para el género "spanish"
correlation_matrix = garage_df[['danceability', 'energy', 'speechiness', 'acousticness', 'instrumentalness', 'liveness', 'valence', 'tempo']].corr()
# Crear un mapa de calor para visualizar la matriz de correlación
plt.figure(figsize=(10, 8))
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', fmt=".2f")
plt.title('Matriz de Correlación entre Características genero spanish')
plt.show()

# Filtrar el DataFrame por género (por ejemplo, indian)
garage_df = df[df['track_genre'] == 'indian']

# Calcular la matriz de correlación para el género "indian"
correlation_matrix = garage_df[['danceability', 'energy', 'speechiness', 'acousticness', 'instrumentalness', 'liveness', 'valence', 'tempo']].corr()
# Crear un mapa de calor para visualizar la matriz de correlación
plt.figure(figsize=(10, 8))
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', fmt=".2f")
plt.title('Matriz de Correlación entre Características genero indian')
plt.show()

# Promedio de popularidad para cada género
avg_popularity = df.groupby('track_genre')['popularity'].mean()
# Top 20 géneros de acuerdo a la popularidad
top_genres = avg_popularity.sort_values(ascending=False).head(114).index
# Filtrar el dataframe
filtered_df = df[df['track_genre'].isin(top_genres)]

# Agrupar por genero y clasificación en explicit
grouped = filtered_df.groupby(['track_genre', 'explicit']).size().unstack(fill_value=0)
# Aplicar logaritmo en base 'e' a los valores para normalizar la cantidad
grouped_log = np.log(grouped + 1)
#print(grouped_log)
#print(grouped_log.columns)
#df_sorted = grouped_log[grouped_log['Index'] == True].sort_values(by='explicit')
# Crear gráfico
plt.rcParams["figure.figsize"] = (20, 12)
grouped_log.plot(kind='bar', color=['blue', 'red'], width=0.5)
plt.xlabel('Género musical', fontsize=16)
plt.ylabel('Cantidad de Canciones (log e)', fontsize=16)
plt.title('Canciones explícitas y no explícitas en log_e para los top 20 géneros musicales más populares')
plt.legend(['No Explícitas', 'Explícitas'], loc='upper right')
plt.show()

# Agrupar por género de la canción y calcular el promedio de duración
avg_duration_by_genre = df.groupby('track_genre')['duration_ms'].mean().reset_index()
avg_duration_by_genre = avg_duration_by_genre.sort_values(by='duration_ms')

# Crear el gráfico de barras
plt.figure(figsize=(24, 16))
plt.bar(avg_duration_by_genre['track_genre'], avg_duration_by_genre['duration_ms'], color='green')
plt.title('Promedio de Duración por Género de la Canción')
plt.xlabel('Género de la Canción')
plt.ylabel('Duración Promedio (ms)')
plt.xticks(rotation=90, ha='right', fontsize=16)  # Rotar las etiquetas del eje x para mayor claridad
plt.grid(axis='y')
plt.show()

df.describe()

import matplotlib.pyplot as plt
import numpy as np
from scipy.spatial.distance import pdist, squareform
genres_of_interest = ['pop', 'rock', 'jazz', 'dance', 'latino', 'reggaeton', 'hip-hop', 'reggae', 'edm', 'latin', 'electro', 'indie', 'alternative', 'house', 'alt-rock', 'garage','k-pop', 'emo', 'indie-pop', 'piano', 'hard-rock', 'british', 'soul', 'singer-songwriter','country', 'songwriter']

correlation_matrices = {}

for genre in genres_of_interest:
    genre_df = df[df['track_genre'] == genre]
    correlation_matrix = genre_df[['danceability', 'energy', 'speechiness', 'acousticness',
                                   'instrumentalness', 'liveness', 'valence', 'tempo']].corr()
    correlation_matrices[genre] = correlation_matrix

def get_upper_triangular(matrix):
    return matrix.where(np.triu(np.ones(matrix.shape), k=1).astype(bool)).stack()

correlation_vectors = {genre: get_upper_triangular(matrix) for genre, matrix in correlation_matrices.items()}

correlation_df = pd.DataFrame(correlation_vectors).T

distances = pdist(correlation_df, metric='euclidean')
distance_matrix = squareform(distances)


similarity_matrix = 1 / (1 + distance_matrix)

plt.figure(figsize=(20, 10))
sns.heatmap(similarity_matrix, annot=True, xticklabels=genres_of_interest, yticklabels=genres_of_interest, cmap='coolwarm', fmt=".2f")
plt.title('Matriz de Similitud entre Matrices de Correlación de Géneros')
plt.show()

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
from scipy.spatial.distance import pdist, squareform

genre_popularity = df.groupby('track_genre')['popularity'].mean()
top_50_genres = genre_popularity.sort_values(ascending=False).head(50).index

#Filtrar el DataFrame para incluir solo los 50 géneros más populares
df_50_genres = df[df['track_genre'].isin(top_50_genres)]

#Crear un diccionario para almacenar las matrices de correlación
correlation_matrices = {}

for genre in top_50_genres:
    genre_df = df_50_genres[df_50_genres['track_genre'] == genre]
    correlation_matrix = genre_df[['danceability', 'energy', 'speechiness', 'acousticness',
                                   'instrumentalness', 'liveness', 'valence', 'tempo']].corr()
    correlation_matrices[genre] = correlation_matrix

#Función para obtener la parte triangular superior de la matriz
def get_upper_triangular(matrix):
    return matrix.where(np.triu(np.ones(matrix.shape), k=1).astype(bool)).stack()

#Obtener los vectores de correlación para cada género
correlation_vectors = {genre: get_upper_triangular(matrix) for genre, matrix in correlation_matrices.items()}

# Convertir el diccionario en un DataFrame
correlation_df = pd.DataFrame(correlation_vectors).T

# Calcular la matriz de distancias
distances = pdist(correlation_df, metric='euclidean')
distance_matrix = squareform(distances)

# Convertir las distancias en similitudes
similarity_matrix = 1 / (1 + distance_matrix)

# Visualizar la matriz de similitud
plt.figure(figsize=(40, 20))
sns.heatmap(similarity_matrix, annot=True, xticklabels=top_50_genres, yticklabels=top_50_genres, cmap='coolwarm', fmt=".2f")
plt.title('Matriz de Similitud entre Matrices de Correlación de Géneros')
plt.show()

#Lo haremos con algunos generos de interes
top_20_genres = ['pop', 'rock', 'jazz', 'dance', 'latino', 'reggaeton', 'hip-hop', 'reggae', 'edm', 'latin', 'electro', 'indie', 'alternative', 'house', 'alt-rock', 'garage','k-pop', 'emo', 'indie-pop', 'piano', 'hard-rock']
#Filtramos
df_top_20 = df[df['track_genre'].isin(top_20_genres)]

#Hacemos los generos una variable dummy
df_dummies = pd.get_dummies(df_top_20['track_genre'], prefix='genre')

#Combinamos
df_combined = pd.concat([df_top_20, df_dummies], axis=1)

columns_of_interest = ['danceability', 'energy', 'loudness', 'mode', 'speechiness',
                       'acousticness', 'instrumentalness', 'liveness', 'valence',
                       'tempo'] + list(df_dummies.columns)
df_numerical = df_combined[columns_of_interest]

#Matriz de correlación
correlation_matrix = df_numerical.corr()
plt.figure(figsize=(20, 15))
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm')

<Axes: >

# Agrupa los datos por género y calcula la media de loudness
loudness_df = df.groupby('track_genre')['loudness'].mean().reset_index()

# Gráfico de loudness vs género
plt.figure(figsize=(24, 16))
plt.bar(loudness_df['track_genre'], loudness_df['loudness'])
plt.xlabel('Género')
plt.ylabel('Loudness (dB)')
plt.title('Loudness vs Género')
plt.xticks(rotation=90, ha='right', fontsize=16)
plt.tight_layout()
plt.show()

# Agrupa los datos por género y cuenta la frecuencia de keys
key_counts_df = df.groupby('track_genre')['key'].value_counts().unstack(fill_value=0)

# Reorganiza el DataFrame para tener una fila por género
key_counts_df = key_counts_df.reset_index()

# Define los colores para cada barra en el gráfico
colors = plt.cm.tab20.colors[:len(key_counts_df.columns) - 1]

# Gráfico de frecuencia de keys por género
plt.figure(figsize=(24, 16))
for i, key in enumerate(key_counts_df.columns[1:]):  # Comienza desde la segunda columna (la primera es 'track_genre')
    plt.bar(key_counts_df['track_genre'], key_counts_df[key], label=key, color=colors[i])

plt.xlabel('Género')
plt.ylabel('Frecuencia de Keys')
plt.title('Frecuencia de Keys por Género')
plt.xticks(rotation=90, ha='right', fontsize=16)
plt.legend(title='Key', bbox_to_anchor=(1, 1), loc='upper left')
plt.tight_layout()
plt.show()

# Agrupa los datos por género y cuenta la frecuencia de mode
mode_counts_df = df.groupby('track_genre')['mode'].value_counts().unstack(fill_value=0)

# Reorganiza el DataFrame para tener una fila por género
mode_counts_df = mode_counts_df.reset_index()

# Define los colores para cada barra en el gráfico
colors = plt.cm.tab20.colors[:len(mode_counts_df.columns) - 1]

# Gráfico de frecuencia de mode por género
plt.figure(figsize=(24, 16))
for i, mode in enumerate(mode_counts_df.columns[1:]):  # Comienza desde la segunda columna (la primera es 'track_genre')
    plt.bar(mode_counts_df['track_genre'], mode_counts_df[mode], label=mode, color=colors[i])

plt.xlabel('Género')
plt.ylabel('Frecuencia de Mode')
plt.title('Frecuencia de Mode por Género')
plt.xticks(rotation=90, ha='right', fontsize=16)
plt.legend(title='Mode', bbox_to_anchor=(1, 1), loc='upper left')
plt.tight_layout()
plt.show()

# Agrupa los datos por género y cuenta la frecuencia de time_signature
time_signature_counts_df = df.groupby('track_genre')['time_signature'].value_counts().unstack(fill_value=0)

# Reorganiza el DataFrame para tener una fila por género
time_signature_counts_df = time_signature_counts_df.reset_index()

# Define los colores para cada barra en el gráfico
colors = plt.cm.tab20.colors[:len(time_signature_counts_df.columns) - 1]

# Gráfico de frecuencia de time_signature por género
plt.figure(figsize=(24, 16))
for i, time_signature in enumerate(time_signature_counts_df.columns[1:]):  # Comienza desde la segunda columna (la primera es 'track_genre')
    plt.bar(time_signature_counts_df['track_genre'], time_signature_counts_df[time_signature], label=time_signature, color=colors[i])

plt.xlabel('Género')
plt.ylabel('Frecuencia de Time Signature')
plt.title('Frecuencia de Time Signature por Género')
plt.xticks(rotation=90, ha='right', fontsize=16)
plt.legend(title='Time Signature', bbox_to_anchor=(1, 1), loc='upper left')
plt.tight_layout()
plt.show()

df['time_signature'].value_counts()

time_signature
4    101843
3      9195
5      1826
1       973
0       163
Name: count, dtype: int64

import pandas as pd
import numpy as np
# Metricas de similitud
from scipy.spatial.distance import euclidean, cityblock
from scipy.stats import pearsonr
from sklearn.metrics.pairwise import cosine_similarity
# Graficos
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
# Procesamiento
from sklearn.preprocessing import StandardScaler, OneHotEncoder # Estandarizacion
from sklearn.preprocessing import MinMaxScaler # Normalizacion
from sklearn.decomposition import PCA
# Split
from sklearn.model_selection import train_test_split
# Sampling
from imblearn.over_sampling import RandomOverSampler
from imblearn.under_sampling import RandomUnderSampler
# Models
from sklearn import svm
from sklearn.svm import SVC  # Support Vector Machine
from sklearn.ensemble import GradientBoostingClassifier # GradientBoost
from sklearn.naive_bayes import GaussianNB # Bayes
# Metrics
from sklearn.metrics import classification_report
from sklearn.metrics import make_scorer, precision_score
from sklearn.model_selection import cross_val_score
# GridSearch
from sklearn.model_selection import GridSearchCV
#from sklearn.metrics import confusion_matrix

##### FILTRADO DE GÉNEROS POR POPULARIDAD #####

# Top 10 géneros más populares:
num_genres = 10
# 1. Promedio de popularidad por género
genre_popularity = df.groupby('track_genre')['popularity'].mean()
# 2. 50 género más populares
top_genres = genre_popularity.sort_values(ascending=False).head(num_genres).index
# 3. Creamos el nuevo dataframe
df_top_genres = df[df['track_genre'].isin(top_genres)].copy()

# Eliminar columnas que no aportan información relevante: Unnamed, track_id, artists, album_name, track_name
df_top_genres.drop(['Unnamed: 0', 'track_id', 'artists', 'album_name', 'track_name', 'popularity'], axis='columns', inplace=True)

# Atributos musicales que se tendrán en cuenta
# Eliminados: time_signature, mode, duration_ms, keys, explicit
musical_attributes = df_top_genres[['track_genre', 'danceability', 'energy',
                         'loudness', 'speechiness', 'acousticness',
                         'instrumentalness', 'liveness', 'valence', 'tempo']]

print(f"\n *** Se estan considerando los {num_genres} generos mas populares *** \n")
musical_attributes

 *** Se estan considerando los 10 generos mas populares ***

# Separar los atributos musicales de los géneros
attributes = musical_attributes.drop('track_genre', axis=1)
genres = musical_attributes['track_genre']

# Estandarizar los datos
scaler = StandardScaler()
attributes_scaled = scaler.fit_transform(attributes)

# Crear un DataFrame estandarizado y agregar la columna de géneros de nuevo
musical_attributes_scaled = pd.DataFrame(attributes_scaled, columns=attributes.columns)
musical_attributes_scaled['track_genre'] = genres.values

# Calcular el centroide de cada género mediante el promedio
genre_centroids = musical_attributes_scaled.groupby('track_genre').mean()

# Diccionarios para las distancias eucledianas y manhattan
dicc_euclidean = {}
dicc_manhattan = {}
# Limites
euclid_lim = 1
manhatt_lim = 2

# Diccionarios para similitud coseno y correlacion de Pearson
dicc_cosine = {}
dicc_pearson = {}
# Limites
cosine_lim = 0.7
pear_lim = 0.7
# Generos vistos
dicc_genres = {}

# Calcular las distancias entre todos los generos
for genre1 in genre_centroids.index:
    for genre2 in genre_centroids.index:
        if genre1 != genre2 and (genre2, genre1) not in dicc_genres:
          # Guardar que ya se vio el caso
          dicc_genres[(genre1, genre2)] = 1
          # Calculo de metricas
          distance_euclid = euclidean(genre_centroids.loc[genre1], genre_centroids.loc[genre2])
          distance_manhatt = cityblock(genre_centroids.loc[genre1], genre_centroids.loc[genre2])
          cosine_sim = cosine_similarity(genre_centroids.loc[genre1].values.reshape(1, -1), genre_centroids.loc[genre2].values.reshape(1, -1))[0][0]
          pearson_corr, _ = pearsonr(genre_centroids.loc[genre1], genre_centroids.loc[genre2])
          # Distancia euclediana
          if 0 < distance_euclid < euclid_lim:
            dicc_euclidean[(genre1, genre2)] = distance_euclid
          # Distancia manhattan
          if 0 < distance_manhatt < manhatt_lim:
            dicc_manhattan[(genre1, genre2)] = distance_manhatt
          # Similitud coseno
          if cosine_lim <= cosine_sim:
                dicc_cosine[(genre1, genre2)] = cosine_sim
          # Correlacion de Pearson
          if pear_lim <= pearson_corr:
                dicc_pearson[(genre1, genre2)] = pearson_corr
# Mostrar las distancias calculadas
for pair, distance in dicc_euclidean.items():
    print(f"Distancia euclidiana entre {pair[0]} y {pair[1]}: {distance}")
print("\n")

for pair, distance in dicc_manhattan.items():
    print(f"Distancia manhattan entre {pair[0]} y {pair[1]}: {distance}")
print("\n")

for pair, distance in dicc_cosine.items():
    print(f"Similitud Coseno entre {pair[0]} y {pair[1]}: {distance}")
print("\n")

for pair, distance in dicc_pearson.items():
    print(f"Correlación de Pearson entre {pair[0]} y {pair[1]}: {distance}")
print("\n")

Distancia euclidiana entre chill y sad: 0.5848205433948878
Distancia euclidiana entre emo y k-pop: 0.7863926991097293
Distancia euclidiana entre emo y pop: 0.7930656593261709
Distancia euclidiana entre indian y pop: 0.8002791474779437
Distancia euclidiana entre indian y pop-film: 0.48516890326023265
Distancia euclidiana entre k-pop y pop: 0.47668062492395546
Distancia euclidiana entre k-pop y pop-film: 0.8217132662131349
Distancia euclidiana entre pop y pop-film: 0.5148214329997334


Distancia manhattan entre chill y sad: 1.4733272367327162
Distancia manhattan entre emo y k-pop: 1.885545813332767
Distancia manhattan entre indian y pop-film: 1.2062134589628986
Distancia manhattan entre k-pop y pop: 1.1950155609940454
Distancia manhattan entre pop y pop-film: 1.2373181145239005


Similitud Coseno entre chill y sad: 0.9227687466640525
Similitud Coseno entre indian y pop-film: 0.7156395644728744
Similitud Coseno entre k-pop y pop: 0.760057998619438


Correlación de Pearson entre chill y sad: 0.9255625193128174
Correlación de Pearson entre k-pop y pop: 0.8296569830959191

# DATAFRAME ESTANDARIZADO

# Definición: Transforma los datos para que tengan una media de 0 y una desviación estándar de 1.

##### FILTRADO DE GÉNEROS POR POPULARIDAD #####

# Top 10 géneros más populares:
num_genres = 10
# 1. Promedio de popularidad por género
genre_popularity = df.groupby('track_genre')['popularity'].mean()
# 2. Género más populares
top_genres = genre_popularity.sort_values(ascending=False).head(num_genres).index
# 3. Creamos el nuevo dataframe
df_top_genres = df[df['track_genre'].isin(top_genres)].copy()

# Eliminar columnas que no aportan información relevante: Unnamed, track_id, artists, album_name, track_name
df_top_genres.drop(['Unnamed: 0', 'track_id', 'artists', 'album_name', 'track_name', 'popularity'], axis = 'columns', inplace=True)

# Atributos musicales que se tendrán en cuenta
# Eliminados: time_signature, mode, duration_ms, keys, explicit
musical_attributes = df_top_genres[['track_genre', 'danceability', 'energy',
                         'loudness', 'speechiness', 'acousticness',
                         'instrumentalness', 'liveness', 'valence', 'tempo']]

# Separar los atributos musicales de los géneros
attributes = musical_attributes.drop('track_genre', axis=1)
genres = musical_attributes['track_genre']

# Estandarizar los datos
scaler = StandardScaler()
attributes_scaled = scaler.fit_transform(attributes)

# Crear un DataFrame estandarizado y agregar la columna de géneros de nuevo
df_model = pd.DataFrame(attributes_scaled, columns=attributes.columns)
df_model['track_genre'] = genres.values

# Merge:
# Combinar con pop
df_model['track_genre'] = df_model['track_genre'].replace('k-pop', 'pop')
df_model['track_genre'] = df_model['track_genre'].replace('indian', 'pop')
df_model['track_genre'] = df_model['track_genre'].replace('pop-film', 'pop')
# Combinar sad con chill
df_model['track_genre'] = df_model['track_genre'].replace('sad', 'chill')

df_model

# Géneros
df_model['track_genre'].unique()

array(['anime', 'chill', 'emo', 'grunge', 'pop', 'sertanejo'],
      dtype=object)

# Codigo General para el Split

### SPLIT ###
# Separar las características y la variable objetivo
X = df_model.drop(columns='track_genre', axis=1)
y = df_model['track_genre']

## 4.000 -> Pop
## 2.000 -> Chill
## 1.000 -> grunge, sertanejo, emo, anime

# Training = 0.80
# Pop -> 3200
# Chill -> 1800
# Los demas -> 800

# Dividir los datos en entrenamiento y prueba

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=39, stratify=y)

# Agrupar los datos por género y contar la cantidad de canciones en cada grupo
songs_per_genre = df_model.groupby('track_genre').size()

# Imprimir la cantidad de canciones por género en X_train
print("Cantidad de canciones por género en df_model:")
print(songs_per_genre)

# Definir las clases para subsampling y oversampling para los conjuntos de Training
over_classes = ['grunge', 'sertanejo', 'emo', 'anime', 'chill']
sub_class = ['pop']

# Configuración deseada de Random Oversampling y Undersampling
target_samples_over = 2000
target_samples_sub = 2000
ros = RandomOverSampler(sampling_strategy={cls: target_samples_over for cls in over_classes})
rus = RandomUnderSampler(sampling_strategy={cls: target_samples_sub for cls in sub_class})

# Aplicar Random Oversampling y Undersampling
X_resampled, y_resampled = ros.fit_resample(X_train, y_train)
X_resampled, y_resampled = rus.fit_resample(X_resampled, y_resampled)

# Imprimir resultado de X_train como resampled
print('\n Valores finales de X_resampled que será usado para el entrenamiento')
print(y_resampled.value_counts())

Cantidad de canciones por género en df_model:
track_genre
anime        1000
chill        2000
emo          1000
grunge       1000
pop          4000
sertanejo    1000
dtype: int64

 Valores finales de X_resampled que será usado para el entrenamiento
track_genre
anime        2000
chill        2000
emo          2000
grunge       2000
pop          2000
sertanejo    2000
Name: count, dtype: int64

### Modelo Base SVM ###

# Instanciar el modelo
nb_clf = SVC()  # kernel='rbf'

# Entrenar el modelo
nb_clf.fit(X_resampled, y_resampled)

# Predecir
y_pred = nb_clf.predict(X_test)

# Resultados
print(classification_report(y_test, y_pred))

              precision    recall  f1-score   support

       anime       0.46      0.50      0.48       200
       chill       0.59      0.63      0.61       400
         emo       0.28      0.21      0.24       200
      grunge       0.47      0.77      0.58       200
         pop       0.75      0.58      0.66       800
   sertanejo       0.60      0.76      0.67       200

    accuracy                           0.58      2000
   macro avg       0.52      0.57      0.54      2000
weighted avg       0.60      0.58      0.58      2000

### Modelo GridSearch SVM ###
# Parámetros a explorar mediante GridSearchCV
param_grid = {'C': [0.1, 1, 10],
              'gamma': [1, 0.1],
              'kernel': ['rbf', 'linear']}

# Instanciar el modelo
svm_clf = SVC()

# Instanciar GridSearchCV
grid_search = GridSearchCV(svm_clf, param_grid, cv=5, n_jobs=-1)

# Entrenar GridSearchCV para encontrar los mejores hiperparámetros
grid_search.fit(X_train, y_train)

# Mejores hiperparámetros encontrados
best_params = grid_search.best_params_
print("Mejores hiperparámetros encontrados:", best_params)

# Entrenar el modelo SVM con los mejores hiperparámetros encontrados
best_svm_clf = SVC(**best_params)
best_svm_clf.fit(X_train, y_train)

# Predecir con el modelo mejorado
y_pred_best = best_svm_clf.predict(X_test)

# Resultados del modelo mejorado
print("Resultados del modelo SVM con mejores hiperparámetros:")
print(classification_report(y_test, y_pred_best))

Mejores hiperparámetros encontrados: {'C': 10, 'gamma': 0.1, 'kernel': 'rbf'}
Resultados del modelo SVM con mejores hiperparámetros:
              precision    recall  f1-score   support

       anime       0.60      0.42      0.49       200
       chill       0.66      0.53      0.59       400
         emo       0.46      0.11      0.18       200
      grunge       0.57      0.69      0.62       200
         pop       0.63      0.88      0.74       800
   sertanejo       0.80      0.56      0.66       200

    accuracy                           0.64      2000
   macro avg       0.62      0.53      0.55      2000
weighted avg       0.63      0.64      0.61      2000

from sklearn.metrics import confusion_matrix

cm = confusion_matrix(y_test, y_pred_best, normalize='true') # calcula valores de la matriz de confusión

fig, ax = plt.subplots()

labels = np.array(['anime', 'chill', 'emo', 'grunge', 'pop', 'sertanejo'])

ax = sns.heatmap(cm, annot=True, cmap='coolwarm', xticklabels=labels, yticklabels=labels) # transforma la matriz en un heatmap para su visualización

ax.set_title('Confusion Matrix \n')
ax.set_xlabel('Predicted label')
ax.set_ylabel('True label')

plt.xticks()
plt.yticks(rotation=0)

plt.show()

# Intanciamos el modelo
GB_clf = GradientBoostingClassifier()
# Entrenar el modelo
GB_clf.fit(X_resampled, y_resampled)

GradientBoostingClassifier()

GradientBoostingClassifier()

# Predecir
y_pred = GB_clf.predict(X_test)
# Resultados
print(classification_report(y_test, y_pred))

              precision    recall  f1-score   support

       anime       0.46      0.50      0.48       200
       chill       0.59      0.63      0.61       400
         emo       0.28      0.21      0.24       200
      grunge       0.47      0.77      0.58       200
         pop       0.75      0.58      0.66       800
   sertanejo       0.60      0.76      0.67       200

    accuracy                           0.58      2000
   macro avg       0.52      0.57      0.54      2000
weighted avg       0.60      0.58      0.58      2000

# Definimos semilla
np.random.seed(7)

# Set scoring metric
score = make_scorer(precision_score, average='macro')

# Configure tuned_parameters
# Los parametros de GBC son loss, learning_rate, n_estimators, subsample,
# criterion, min_samples_split, min_samples_leaf, max_depth, max_features

tuned_parameters = {
    "learning_rate": [0.1],
    "n_estimators": [10, 100],
    "max_depth": [3, 8],
}

# Construcción del clf para gridsearch
clf_GB = GridSearchCV(
        GradientBoostingClassifier(),
        param_grid=tuned_parameters,
        cv=3,
        scoring='accuracy',
        n_jobs=-1
)

# Entrenar clf
clf_GB.fit(X_resampled, y_resampled)

print("Mejor combinación de parámetros:")
print(clf_GB.best_params_)

y_pred = clf_GB.predict(X_test)
print(classification_report(y_test, y_pred))

Mejor combinación de parámetros:
{'learning_rate': 0.1, 'max_depth': 8, 'n_estimators': 100}
              precision    recall  f1-score   support

       anime       0.52      0.54      0.53       200
       chill       0.55      0.65      0.60       400
         emo       0.29      0.24      0.26       200
      grunge       0.67      0.70      0.69       200
         pop       0.78      0.72      0.75       800
   sertanejo       0.72      0.74      0.73       200

    accuracy                           0.64      2000
   macro avg       0.59      0.60      0.59      2000
weighted avg       0.64      0.64      0.64      2000

from sklearn.metrics import confusion_matrix

cm = confusion_matrix(y_test, y_pred_best, normalize='true') # calcula valores de la matriz de confusión

fig, ax = plt.subplots()

labels = np.array(['anime', 'chill', 'emo', 'grunge', 'pop', 'sertanejo'])

ax = sns.heatmap(cm, annot=True, cmap='coolwarm', xticklabels=labels, yticklabels=labels) # transforma la matriz en un heatmap para su visualización

ax.set_title('Confusion Matrix \n')
ax.set_xlabel('Predicted label')
ax.set_ylabel('True label')

plt.xticks()
plt.yticks(rotation=0)

plt.show()

# Intento de hacer cross validation
from sklearn.model_selection import cross_validate

clf_GB = GradientBoostingClassifier(learning_rate=0.3, max_depth=8, n_estimators=100)

scoring = ['precision_macro', 'recall_macro', 'accuracy', 'f1_macro']

# Configurando validación cruzada
cv_results = cross_validate(clf_GB, X, y, cv=5, scoring=scoring)

print('Promedio Precision:', np.mean(cv_results['test_precision_macro']))
print('Promedio Recall:   ', np.mean(cv_results['test_recall_macro']))
print('Promedio F1-score: ', np.mean(cv_results['test_f1_macro']))
print('Promedio Accucary: ', np.mean(cv_results['test_accuracy']))

Promedio Precision: 0.5911450125821642
Promedio Recall:    0.5537500000000001
Promedio F1-score:  0.565136144507209
Promedio Accucary:  0.6327

# Modelo Bayesiano
clf = GaussianNB()
clf.fit(X_resampled, y_resampled)

y_pred = clf.predict(X_test)

print(classification_report(y_test, y_pred))

              precision    recall  f1-score   support

       anime       0.45      0.23      0.30       200
       chill       0.55      0.41      0.47       400
         emo       0.23      0.16      0.19       200
      grunge       0.48      0.58      0.53       200
         pop       0.58      0.19      0.28       800
   sertanejo       0.19      0.92      0.32       200

    accuracy                           0.35      2000
   macro avg       0.41      0.42      0.35      2000
weighted avg       0.48      0.35      0.34      2000

##Cuadricula de parámetros
param_grid = {
    'var_smoothing': np.logspace(0, -9, num=100)
}

GridSearchCV
clf = GridSearchCV(estimator=GaussianNB(),
                   param_grid=param_grid,
                   cv=5,
                   n_jobs=-1,
                   scoring='accuracy')

clf.fit(X_train, y_train)

print("Mejores parámetros encontrados por GridSearchCV:")
print(clf.best_params_)

y_pred = clf.predict(X_test)

print(classification_report(y_test, y_pred))

Mejores parámetros encontrados por GridSearchCV:
{'var_smoothing': 0.2848035868435802}
              precision    recall  f1-score   support

       anime       0.69      0.20      0.31       200
       chill       0.58      0.37      0.45       400
         emo       0.31      0.09      0.13       200
      grunge       0.45      0.69      0.54       200
         pop       0.56      0.82      0.67       800
   sertanejo       0.70      0.56      0.62       200

    accuracy                           0.56      2000
   macro avg       0.55      0.45      0.46      2000
weighted avg       0.56      0.56      0.52      2000

from sklearn.metrics import confusion_matrix

cm = confusion_matrix(y_test, y_pred_best, normalize='true') # calcula valores de la matriz de confusión

fig, ax = plt.subplots()

labels = np.array(['anime', 'chill', 'emo', 'grunge', 'pop', 'sertanejo'])

ax = sns.heatmap(cm, annot=True, cmap='coolwarm', xticklabels=labels, yticklabels=labels) # transforma la matriz en un heatmap para su visualización

ax.set_title('Confusion Matrix \n')
ax.set_xlabel('Predicted label')
ax.set_ylabel('True label')

plt.xticks()
plt.yticks(rotation=0)

plt.show()

	Unnamed: 0	track_id	artists	album_name	track_name	popularity	duration_ms	explicit	danceability	energy	...	loudness	mode	speechiness	acousticness	instrumentalness	liveness	valence	tempo	time_signature	track_genre
0	0	5SuOikwiRyPMVoIQDJUgSV	Gen Hoshino	Comedy	Comedy	73	230666	False	0.676	0.4610	...	-6.746	0	0.1430	0.0322	0.000001	0.3580	0.7150	87.917	4	acoustic
1	1	4qPNDBW1i3p13qLCt0Ki3A	Ben Woodward	Ghost (Acoustic)	Ghost - Acoustic	55	149610	False	0.420	0.1660	...	-17.235	1	0.0763	0.9240	0.000006	0.1010	0.2670	77.489	4	acoustic
2	2	1iJBSr7s7jYXzM8EGcbK5b	Ingrid Michaelson;ZAYN	To Begin Again	To Begin Again	57	210826	False	0.438	0.3590	...	-9.734	1	0.0557	0.2100	0.000000	0.1170	0.1200	76.332	4	acoustic
3	3	6lfxq3CG4xtTiEg7opyCyx	Kina Grannis	Crazy Rich Asians (Original Motion Picture Sou...	Can't Help Falling In Love	71	201933	False	0.266	0.0596	...	-18.515	1	0.0363	0.9050	0.000071	0.1320	0.1430	181.740	3	acoustic
4	4	5vjLSffimiIP26QG5WcN2K	Chord Overstreet	Hold On	Hold On	82	198853	False	0.618	0.4430	...	-9.681	1	0.0526	0.4690	0.000000	0.0829	0.1670	119.949	4	acoustic
...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...
113995	113995	2C3TZjDRiAzdyViavDJ217	Rainy Lullaby	#mindfulness - Soft Rain for Mindful Meditatio...	Sleep My Little Boy	21	384999	False	0.172	0.2350	...	-16.393	1	0.0422	0.6400	0.928000	0.0863	0.0339	125.995	5	world-music
113996	113996	1hIz5L4IB9hN3WRYPOCGPw	Rainy Lullaby	#mindfulness - Soft Rain for Mindful Meditatio...	Water Into Light	22	385000	False	0.174	0.1170	...	-18.318	0	0.0401	0.9940	0.976000	0.1050	0.0350	85.239	4	world-music
113997	113997	6x8ZfSoqDjuNa5SVP5QjvX	Cesária Evora	Best Of	Miss Perfumado	22	271466	False	0.629	0.3290	...	-10.895	0	0.0420	0.8670	0.000000	0.0839	0.7430	132.378	4	world-music
113998	113998	2e6sXL2bYv4bSz6VTdnfLs	Michael W. Smith	Change Your World	Friends	41	283893	False	0.587	0.5060	...	-10.889	1	0.0297	0.3810	0.000000	0.2700	0.4130	135.960	4	world-music
113999	113999	2hETkH7cOfqmz3LqZDHZf5	Cesária Evora	Miss Perfumado	Barbincor	22	241826	False	0.526	0.4870	...	-10.204	0	0.0725	0.6810	0.000000	0.0893	0.7080	79.198	4	world-music

	Unnamed: 0	popularity	duration_ms	danceability	energy	key	loudness	mode	speechiness	acousticness	instrumentalness	liveness	valence	tempo	time_signature
count	114000.000000	114000.000000	1.140000e+05	114000.000000	114000.000000	114000.000000	114000.000000	114000.000000	114000.000000	114000.000000	114000.000000	114000.000000	114000.000000	114000.000000	114000.000000
mean	56999.500000	33.238535	2.280292e+05	0.566800	0.641383	5.309140	-8.258960	0.637553	0.084652	0.314910	0.156050	0.213553	0.474068	122.147837	3.904035
std	32909.109681	22.305078	1.072977e+05	0.173542	0.251529	3.559987	5.029337	0.480709	0.105732	0.332523	0.309555	0.190378	0.259261	29.978197	0.432621
min	0.000000	0.000000	0.000000e+00	0.000000	0.000000	0.000000	-49.531000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000
25%	28499.750000	17.000000	1.740660e+05	0.456000	0.472000	2.000000	-10.013000	0.000000	0.035900	0.016900	0.000000	0.098000	0.260000	99.218750	4.000000
50%	56999.500000	35.000000	2.129060e+05	0.580000	0.685000	5.000000	-7.004000	1.000000	0.048900	0.169000	0.000042	0.132000	0.464000	122.017000	4.000000
75%	85499.250000	50.000000	2.615060e+05	0.695000	0.854000	8.000000	-5.003000	1.000000	0.084500	0.598000	0.049000	0.273000	0.683000	140.071000	4.000000
max	113999.000000	100.000000	5.237295e+06	0.985000	1.000000	11.000000	4.532000	1.000000	0.965000	0.996000	1.000000	1.000000	0.995000	243.372000	5.000000

Tarea	Encargado/a
Trabajo en la Presentación	Scarlett Plaza
	Vicente Thiele
Trabajo en el Informe
	Javiera Romero
	Patricio Espinoza
	Rodrigo Díaz
Revisión Problemas
	Rodrigo Díaz
	Vicente Thiele
	Scarlett Plaza
Gráficos de Matrices de Correlación por género
	Javiera Romero
	Scarlett Plaza
Gráfico Cantidad de Aparición de los Géneros en las 300 Canciones más Populares
	Javiera Romero
Gráfico Popularidad Promedio por Género
	Rodrigo Díaz
Gráfico Cantidad de Canciones por Género
	Rodrigo Díaz
Gráfico Género por Explícito
	Patricio Espinoza
Gráfico de Duración Promedio por Género
	Patricio Espinoza
Análisis mediante .describe()
	Patricio Espinoza

	track_genre	danceability	energy	loudness	speechiness	acousticness	instrumentalness	liveness	valence	tempo
5000	anime	0.541	0.846	-2.729	0.0551	0.01220	0.000149	0.1630	0.524	129.138
5001	anime	0.436	0.934	-2.685	0.0507	0.00001	0.140000	0.3210	0.384	91.481
5002	anime	0.577	0.941	-5.170	0.1050	0.00207	0.000003	0.0891	0.292	101.921
5003	anime	0.508	0.889	-2.755	0.0862	0.04950	0.000000	0.0984	0.332	135.014
5004	anime	0.691	0.773	-5.244	0.0494	0.01740	0.000451	0.1170	0.502	128.162
...	...	...	...	...	...	...	...	...	...	...
97995	sertanejo	0.769	0.718	-5.809	0.0241	0.23400	0.000000	0.1680	0.725	105.015
97996	sertanejo	0.529	0.564	-4.713	0.0247	0.66800	0.000000	0.1960	0.594	160.445
97997	sertanejo	0.690	0.926	-5.584	0.1830	0.33600	0.000000	0.0319	0.867	178.119
97998	sertanejo	0.763	0.769	-6.245	0.0292	0.23500	0.000041	0.0545	0.857	92.035
97999	sertanejo	0.771	0.722	-8.718	0.0327	0.13800	0.000000	0.1270	0.940	130.065

	danceability	energy	loudness	speechiness	acousticness	instrumentalness	liveness	valence	tempo	track_genre
0	-0.400210	1.020159	1.264896	-0.354629	-1.105335	-0.316035	-0.248729	0.209662	0.251332	anime
1	-1.100814	1.417516	1.276165	-0.405292	-1.144952	0.334837	0.603849	-0.423663	-0.988431	anime
2	-0.160003	1.449123	0.639754	0.219933	-1.138258	-0.316713	-0.647498	-0.839848	-0.644720	anime
3	-0.620400	1.214322	1.258238	0.003465	-0.984107	-0.316728	-0.597314	-0.658898	0.444785	anime
4	0.600653	0.690533	0.620802	-0.420260	-1.088434	-0.314629	-0.496947	0.110140	0.219200	anime
...	...	...	...	...	...	...	...	...	...	...
9995	1.121102	0.442185	0.476105	-0.711571	-0.384470	-0.316728	-0.221748	1.118936	-0.542858	sertanejo
9996	-0.480279	-0.253190	0.756792	-0.704663	1.026059	-0.316728	-0.070659	0.526325	1.282038	sertanejo
9997	0.593981	1.381392	0.533728	1.118047	-0.052963	-0.316728	-0.956152	1.761309	1.863910	sertanejo
9998	1.081067	0.672471	0.364445	-0.652848	-0.381220	-0.316537	-0.834201	1.716071	-0.970192	sertanejo
9999	1.134447	0.460246	-0.268893	-0.612548	-0.696476	-0.316728	-0.442987	2.091543	0.281851	sertanejo

	genre	count
0	acoustic	1000
1	punk-rock	1000
2	progressive-house	1000
3	power-pop	1000
4	pop	1000
...	...	...
109	folk	1000
110	emo	1000
111	electronic	1000
112	electro	1000
113	world-music	1000

Informe Hito 1¶

Grupo 1¶

Motivación¶

Análisis exploratorio¶

Género de las canciones más populares¶

Matrices de correlación por género¶

Cantidad de canciones explicitas y no explicitas por género¶

Duración promedio por género¶

Análisis mediante funcionalidad describe()¶

Preguntas y problemas¶

Código análisis exploratorio¶

Código¶

Paquetes¶

Cargar dataset¶

Cantidad de canciones por género¶

Género de las canciones más populares¶

Géneros de las 300 canciones más populares del dataset¶

Promedio de popularidad por género¶

Matrices de correlación por género¶

Matriz de correlacion para género pop¶

Matriz de correlacion para género dance¶

Matriz de correlación de género latino¶

Matriz de correlación de género reggaeton¶

Matriz de correlacion de género hip-hop¶

Matriz de correlacion de género reggae¶

Matriz de correlacion de género rock¶

Matriz de correlacion de género edm¶

Matriz de correlación de género latin¶

Matriz de correlacion de género electro¶

Matriz de correlación de género indie¶

Matriz de correlacion de género alternative¶

Matriz de correlacion de género house¶

Matriz de correlación de género alt-rock¶

Matriz de correlación de género garage¶

Matriz de correlación género k-pop¶

Matriz de correlación género emo¶

Matriz de correlación género indie-pop¶

Matriz de correlación género piano¶

Matriz de correlación género hard-rock¶

Matriz de correlación género british¶

Matriz de correlación género soul¶

Matriz de correlación género progressive-house¶

Matriz de correlación género singer-songwriter¶

Matriz de correlación género country¶

Matriz de correlación género songwriter¶

Matriz de correlación género funk¶

Matriz de correlación género spanish¶

Matriz de correlación género indian¶

Cantidad de canciones explicitas y no explicitas por género¶

Duración promedio de las canciones por género¶

Análisis mediante funcionalidad describe()¶

Contribución de miembros Hito 1¶

Mejoras Hito 1¶

Mejorar fase exploratoria¶

Matriz de correlacion entre generos, muestra similitud entre generos¶

Matriz de correlacion incluyendo los generos¶

Loudness promedio por género¶

Keys por género¶

Mode por género¶

Time_signature por género¶

Conclusión Hito 1¶

Informe Hito 2¶

2. Propuesta metodológica experimental inicial:¶

3. Resultado preliminar¶

Importar librerias necesarias¶

Pre-procesamiento¶

Metricas de distancia y similitud¶

Dataset para el modelo¶

Crear modelos¶

Support Vector Machine (SVM)¶

GradientBoost¶

Bayes¶

Conclusión¶

Contribución miembros Hito 2¶